﻿#define _CRT_SECURE_NO_WARNINGS
// ↑ 将本行在代码放在第一行可以避免 scanf的报错问题（仅在VS编译器里）

//【入门】8.内存管理(1)
//【入门】9.内存管理(2)



//【头文件包含】
//C++的主要头文件



#include<iostream>//c++的输入输出流
using std::cout, std::endl,std::cin,std::string;
//C的主要头文件
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<string.h> 




//【命名空间】

//【结构体声明】【类声明】
/*创建一个类计算字符串日期是当年的第几天*/class Solution {
public:
    int getyear(string date)
    {
        int year = (date[0] * 1000 + date[1] * 100 + date[2] * 10 + date[3]) - '0' * 1111;
        return year;
    }
    int getmonth(string date)
    {
        int month = date[5] * 10 + date[6] - '0' * 11;
        return month;
    }
    int getday(string date)
    {
        int day = date[8] * 10 + date[9] - '0' * 11;
        return day;
    }
    bool is4year(int year)
    {
        if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)
        {
            return true;
        }
        else return false;
    }
    int dayOfYear(string date)
    {
        int monthday[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
        int sumday = getday(date);
        int month = getmonth(date);
        while (--month)
        {
            sumday += monthday[month];
        }
        int year = getyear(date);
        if (is4year(year) && getmonth(date) > 2)
        {
            sumday += 1;
        }
        return sumday;
    }
};

typedef struct ListNode_C
{
    int _val;
    struct ListNode_C* _next;
    struct ListNode_C* _prev;
}LiseNode_C;

struct ListNode_CPP
{
    int _val;
    ListNode_CPP* _next;
    ListNode_CPP* _prev;
    ListNode_CPP(int val = 0)
        :_val(val), _next(nullptr), _prev(nullptr)
    {}
    ~ListNode_CPP()
    {
        cout << " ~ListNode_CPP" << endl;
    }
};

class A
{
public:
    A(int a = 0)
        :_a(a)
    {
        cout << "A" << endl;
    }
    ~A()
    {
        cout << "~A" << endl;
    }
private:
    int _a;
};


/*模版示例*/template<class T>
void Swap(T& x1, T& x2)
{
    T x = x1;
    x1 = x2;
    x2 = x;
}

//【函数声明】
void Test1(); void Test2(); void Test3(); void Test4();


//【主函数】
int main()
{
	
	Test1();
    Test2();
    Test3();
    Test4();
	
	cout << "****主函数结束****" << endl;
	return 0;
}

//【函数定义】


/*测试用例*/void Test1()
{
	printf("****测试用例开始****\n");
    string date1 = "2025-04-27";
    string date2 = "2025-08-31";
    cout << Solution().dayOfYear(date1) << endl;
    cout << Solution().dayOfYear(date2) << endl;
	printf("****测试用例结束****\n\n");
}

/*测试用例*/void Test2()
{
	printf("****测试用例开始****\n");
    int* p1 = (int*)malloc(sizeof(int));
    int* p2 = (int*)malloc(sizeof(int)*10);
    int* p3 = new int;
    int* p4 = new int[10];
    int* p5 = new int(10); //1个int大小的空间初始化成10
    free(p1);
    free(p2);
    delete p3;
    delete[]p4;

    ListNode_CPP*node1 = new ListNode_CPP;
    delete node1;
	printf("****测试用例结束****\n\n");
}

/*测试用例*/void Test3()
{
	printf("****测试用例开始****\n");
    A a;
    A* p1 = (A*)malloc(sizeof(A));
    free(p1);

    //显示嗲用A的构造函数和析构函数
    A* p2 = (A*)operator new(sizeof(A));
    new(p2)(A)(10);//定位NEW
    p2->~A();//定位析构？
    operator delete(p2);

    A* p3 = new A;
    delete p3;
	printf("****测试用例结束****\n\n");
}

/*测试用例*/void Test4()
{
    printf("****测试用例开始****\n");
    int a = 0, b = 1;
    double c = 2.1, d = 0.2;
    Swap(a, b);
    Swap(c, d);
    cout << a <<" " << b << endl;
    cout << c <<" " << d << endl;
    printf("****测试用例结束****\n\n");
}

//【笔记】
//匿名对象：只使用一次某个对象时，可以以匿名对象形式实现
	//在调用类的一些函数时可以采用匿名对象进行调用 "类名().成员函数名(参数)"
	//匿名对象生命周期仅在该行代码  
//【入门】8.内存管理(1)
    //一些变量在内存中的存放 
        //数据段（静态区）:静态变量、全局变量存放在该区
        //栈区：局部变量存放在该区
        //堆区：动态内存空间存放在该区
        //代码段：可执行代码、只读常量存放在该区
	//32位虚拟内存容量为2^32个字节，而64位虚拟内存为2^64个字节
    //为保证地址编号满足统计全部内存大小所以64为机器地址是8个字节
    //内存空间申请
   //C++申请内存空间     
     //C语言申请动态内存空间使用malloc、calloc（带初始）、realloc、free
   //C++申请内存空间 
     //有新的用法 操作符 new  配合delete使用  new 变量类型[变量元素个数，1个则省略] 用“（数字）”表示初始化|delete[] 开辟空间指针名
     //对于申请内置类型效果和C语言的一样//对于申请自定义类的类型效果和C语言不一样
     // C语言malloc等仅申请空间new除了申请空间，还调用构造函数初始化
     // C语言free仅释放空间delete 先调用析构函数、再释放空间
//【入门】9.内存管理(2)
     //operator new
        // void* operator new(size_t n) 和malloc使用类似 开辟空间失败会抛异常，        //malloc 失败返回错误码
        //operator new= malloc + 失败抛异常
        //new= operator new + 构造函数 
    //operator delete
        //和free没有区别，因为释放空间失败都时之间终止程序
        //delete=free+析构函数
    //operator new和operator delete的自定义（符号重载）
        // 都可以在类中进行自定义形成类专属的new和delete
    //定位new 或replacement new;
        //对已经存在的空间调用构造函数初始化：new(类指针)类名()
        // delete时 先 类指针->~类名()  再operator delete
//下一节开头：模版/泛型编程
    //模版有两类：一种是函数模版、另一种是类模板
        //函数模版
            // 概念：利用模版创建一个无变量类型的函数模版，可以替代不同类型变量调用的函数重载
            // 格式：template<class 模版参数名>  或 template<typename 模版参数名>  后续跟函数模版带入模版参数
            // 原理：使用时并非直接调用函数模版而是调用利用函数模版实例化(推演)生成的对应类型函数，推演发生的时间是在代码预处理时（编译前）
            // 因为函数模版不参与编译所以函数模版内的代码实现错误不会直接检查出要在编译实例化时被发现
            // 实例化：函数名(使用类型)
            // 参数匹配原则：
        //类模版
            // 格式：template<class 模版参数名> 后续跟类模版带入模版参数
            // 实例化：类名<使用类型> 对象名




